<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en" xml:lang="en" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<head>
<META http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Concept: Iteration</title>
<meta name="uma.type" content="Concept">
<meta name="uma.name" content="iteration">
<meta name="uma.presentationName" content="Iteration">
<meta name="element_type" content="concept">
<meta name="filetype" content="description">
<meta name="role" content="">
<link rel="StyleSheet" href="./../../../css/default.css" type="text/css">
<script src="./../../../scripts/ContentPageResource.js" type="text/javascript" language="JavaScript"></script><script src="./../../../scripts/ContentPageSection.js" type="text/javascript" language="JavaScript"></script><script src="./../../../scripts/ContentPageSubSection.js" type="text/javascript" language="JavaScript"></script><script src="./../../../scripts/ContentPageToolbar.js" type="text/javascript" language="JavaScript"></script><script src="./../../../scripts/contentPage.js" type="text/javascript" language="JavaScript"></script><script type="text/javascript" language="JavaScript">
					var backPath = './../../../';
					var imgPath = './../../../images/';
					var nodeInfo=null;
					contentPage.preload(imgPath, backPath, nodeInfo,  '', false, false, false);
				</script>
</head>
<body>
<div id="breadcrumbs"></div>
<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr>
<td valign="top"><a name="Top"></a>
<div id="page-guid" value="_lam4ADkBEduxovfWMDsntw"></div>
<table border="0" cellspacing="0" cellpadding="0" width="100%">
<tr>
<td class="pageTitle" nowrap="true">Concept: Iteration</td><td width="100%">
<div align="right" id="contentPageToolbar"></div>
</td><td width="100%" class="expandCollapseLink" align="right"><a name="mainIndex" href="./../../../index.htm"></a><script language="JavaScript" type="text/javascript" src="./../../../scripts/treebrowser.js"></script></td>
</tr>
</table>
<table width="100%" border="0" cellpadding="0" cellspacing="0">
<tr>
<td class="pageTitleSeparator"><img src="./../../../images/shim.gif" alt="" title="" height="1"></td>
</tr>
</table>
<div class="overview">
<table width="97%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td width="50"><img src="./../../../images/concept.gif" alt="" title=""></td><td>
<table class="overviewTable" border="0" cellspacing="0" cellpadding="0">
<tr>
<td valign="top">An iteration is a set period of time within a project in which you produce a stable, executable version of the product, together with any other supporting documentation, install scripts, or similar, necessary to use this release. Also referred to as a cycle or a timebox.</td>
</tr>
</table>
</td>
</tr>
</table>
</div>
<div class="sectionHeading">Relationships</div>
<div class="sectionContent">
<table class="sectionTable" border="0" cellspacing="0" cellpadding="0">
<tr valign="top">
<th class="sectionTableHeading" scope="row">Related Elements</th><td class="sectionTableCell">
<ul>
<li>
<a href="./../../../practice.mgmt.risk_value_lifecycle.base/guidances/concepts/construction_phase_873B6559.html" guid="_48EKsBOMEduCNqgZdt_OaA">Construction Phase</a>
</li>
<li>
<a href="./../../../practice.mgmt.risk_value_lifecycle.base/guidances/concepts/elaboration_phase_BE880435.html" guid="_2plxwBOMEduCNqgZdt_OaA">Elaboration Phase</a>
</li>
<li>
<a href="./../../../practice.mgmt.risk_value_lifecycle.base/guidances/concepts/inception_phase_C4456871.html" guid="_0hmKgBOMEduCNqgZdt_OaA">Inception Phase</a>
</li>
<li>
<a href="./../../../practice.mgmt.iterative_dev.base/workproducts/iteration_plan_B46FED39.html" guid="_0aQBEslgEdmt3adZL5Dmdw">Iteration Plan</a>
</li>
<li>
<a href="./../../../practice.mgmt.risk_value_lifecycle.base/guidances/concepts/transition_phase_DD5986E5.html" guid="__ca5UBOMEduCNqgZdt_OaA">Transition Phase</a>
</li>
</ul>
</td>
</tr>
</table>
</div>
<div class="sectionHeading">Main Description</div>
<div class="sectionContent">
<table class="sectionTable" border="0" cellspacing="0" cellpadding="0">
<tr valign="top">
<td class="sectionTableSingleCell"><h3>
    What is an Iteration
</h3>
<p>
    An iteration is a set period of time within a project in which you produce a stable, executable version of the product,
    together with any other supporting documentation, install scripts, or similar, necessary to use this release. The
    executable is demonstrable, allowing the team to demonstrate true progress to stakeholders, get feedback on how they
    are doing so that they can improve their understanding of what needs to be done, and how to do it. Each iteration
    builds upon the results of previous iteration, and will produce a product increment one step closer to the final
    product. Iterations are timeboxed, meaning the schedule for an iteration should be regarded as fixed, and the scope of
    the iteration's content actively managed to meet that schedule.
</p>
<p>
    At each iteration, artifacts are updated. It is said that this is a bit like "growing" software. Instead of developing
    artifacts one after another, in a pipeline fashion, they are evolving across the cycle, although at different rates.
</p>
<p>
    Iterative development is very disciplined: the iteration length is fixed; the objectives of iterations are carefully
    planned; the evaluation criteria are established when each iteration is planned; and the tasks and responsibilities of
    participants are well defined. Additionally, objective measures of progress are captured. Some reworking takes place
    from one iteration to the next, but this too is done in a structured fashion.
</p>
<p>
    Each iteration should address the most critical risks, and implement the highest-priority work items. This ensures that
    each iteration adds maximum stakeholder value, while reducing uncertainty. Iterative development is typically combined
    with frequent or continuous integration: as unit-tested components become available, they are integrated, then a build
    is produced and subjected to integration testing. In this way, the capability of the integrated software grows as the
    iteration proceeds, towards the goals set when the iteration was planned. Regular builds, such as daily or more
    frequent builds, let you break down the integration and test issues and spread them across the development cycle. These
    issues have often been the downfall of large projects because all problems were discovered at once during the single
    massive integration step, which occurred very late in the cycle, and where a single problem halts the whole team.
</p>
<h3>
    What Problem Do Iterations Address?
</h3>
<p>
    Today's software applications are too complex to allow you to sequentially define the requirements, come up with an
    architecture and design, do an implementation, carry out testing, and get it all right. Whether you use waterfall or
    iterative development approaches, your initial requirements, architecture, design, and code will be suboptimal. With
    waterfall development, you typically do not get meaningful feedback on what improvements can be made until it is so
    late in the project that it is too costly to make them. By contrast, dividing the project into a series of time-boxed
    iterations allows you to deliver capabilities that can be assessed by stakeholders at the end of each iteration. This
    approach provides rapid and timely feedback loops enabling issues to be addressed and improvements made at a lower cost
    while budget and time still allow, and before the project has gone so far ahead that major rework is required.
</p>
<h3>
    Iteration Length
</h3>
<p>
    Iterations are typically 4 weeks long, although some teams will work with iterations as short as a week or as long as
    six weeks. For factors driving iteration length, see Table X.
</p>
<p>
    <strong><em>Table 1. Factors Impacting Iteration Length.</em></strong><br />
    &nbsp;<br />
</p>
<table style="WIDTH: 547px; HEIGHT: 356px" cellspacing="2" cellpadding="2" width="547" border="1">
    <tbody>
        <tr>
            <th scope="col">
                Factors leading to reduced iteration length&nbsp;
            </th>
            <th scope="col">
                Factors leading to increased iteration length
            </th>
        </tr>
        <tr>
            <td>
                Small teams&nbsp;
            </td>
            <td>
                Large teams
            </td>
        </tr>
        <tr>
            <td>
                Co-located teams&nbsp;
            </td>
            <td>
                Distributed teams
            </td>
        </tr>
        <tr>
            <td>
                Strong configuration management system&nbsp;
            </td>
            <td>
                Poor configuration management system
            </td>
        </tr>
        <tr>
            <td>
                Dedicated, full-time resources
            </td>
            <td>
                Matrixed or part-time resources
            </td>
        </tr>
        <tr>
            <td>
                Automated testing
            </td>
            <td>
                Lack of automated testing
            </td>
        </tr>
        <tr>
            <td>
                Integrated tool environment&nbsp;
            </td>
            <td>
                Absence of good automation and tool integration
            </td>
        </tr>
        <tr>
            <td>
                Team experienced with iterative development
            </td>
            <td>
                Team inexperienced with iterative development
            </td>
        </tr>
        <tr>
            <td>
                Fast decision making
            </td>
            <td>
                Policies and bureaucracy preventing fast decision making
            </td>
        </tr>
        <tr>
            <td>
                Unclear requirements
            </td>
            <td>
                Well-understood requirements
            </td>
        </tr>
        <tr>
            <td>
                Unclear or brittle architecture
            </td>
            <td>
                Well-defined and stable architecture
            </td>
        </tr>
        <tr>
            <td>
                New and poorly understood technology
            </td>
            <td>
                Well-understood technology
            </td>
        </tr>
    </tbody>
</table><br />
<br />
<h3>
    Why Iterate?
</h3>
<p>
    The iterative approach has proven itself superior to the waterfall approach for a number of reasons:
</p>
<ul>
    <li>
        You are more likely to build an application that addresses user needs. Early specification of requirements often
        leads to unused features. The Standish Group has researched thousands of application development projects and has
        found that more than 45 percent of features are never used, while another 19 percent are used rarely&nbsp; (see
        Figure 2.3). In other words, typically more than half of the development effort is wasted on developing
        nonessential capabilities. To avoid this problem, you need to involve the customer in the development project and
        use an iterative approach that allows you to implement and validate the capabilities deemed most essential in each
        iteration. This approach allows not only early validation of key capabilities but also addition of new capabilities
        late in the project.
    </li>
    <li>
        Integration is not one "big bang" at the end of a project. Leaving integration to the end results in time- and
        budget-consuming rework. To avoid this, an iterative approach breaks a project down into smaller iterations, each
        evolving executable code that is continuously integrated to enable rapid feedback and minimize later revision.
    </li>
    <li>
        Risks are usually discovered or addressed during early iterations. With the iterative approach, risks are more
        likely to be identified and addressed in early iterations. As an example, if there is a risk that a stakeholder
        will not be happy with the functionality you are developing, iterative development will encourage you to&nbsp;
        implement the most essential capabilities partially and demonstrate them to key stakeholders to make sure that you
        are on the right track.
    </li>
    <li>
        Your ability to work effectively is fine-tuned. During early iterations, team members are walking through all
        lifecycle activities, from requirements capture and test definition to development, implementation, and testing.
        Consequently, they can make sure they have the tools, skills, organizational structure, and so on to work
        effectively.
    </li>
    <li>
        Management has a way of making tactical changes to the product. Management can make changes to the product along
        the way-to compete with other new products, for example. Iterative development allows you to evolve partial
        implementations of the end product quickly and use these for quick release of a reduced-scope product to counter a
        competitor's move.
    </li>
    <li>
        Reuse is facilitated. It is easier to identify common parts as they are being partially designed or implemented in
        iterations than to recognize them at the beginning. Discussions and reviews of the design in early iterations allow
        team members to spot potential opportunities for reuse and then develop a mature common code for these
        opportunities in subsequent iterations.
    </li>
    <li>
        Defects can be found and corrected over several iterations. This capability results in a robust architecture and a
        high-quality application. Flaws are detected in early iterations, rather than during a massive testing phase at the
        end. Performance bottlenecks are discovered while they can still be addressed instead of creating panic on the eve
        of delivery.
    </li>
    <li>
        Project personnel are better used. Many organizations match their use of a waterfall approach with a pipeline
        organization: the analysts send the completed requirements to designers, who send a completed design to
        programmers, who send components to integrators, who send a system to testers. These many handoffs are sources of
        errors and misunderstandings and make people feel less responsible for the final product. An iterative process
        encourages widening the scope of expertise of the team members, allowing them to play many roles and thus enabling
        a project manager to make better use of the available staff and simultaneously remove problematic handoffs.
    </li>
    <li>
        Team members learn along the way. The project members have several opportunities within a development cycle to
        learn from their mistakes and improve their skills from one iteration to another. More training opportunities can
        be discovered as a result of assessing the earlier iterations.
    </li>
    <li>
        The development process itself is improved and refined along the way. The iteration assessment allows the team to
        not only look at the project status from a product or scheduling perspective but also analyze what can be improved
        in the next iteration in both the organization and the process.&nbsp;One technique for doing so is to hold a
        retrospective.
    </li>
</ul><br />
<span class="E1"><span style="FONT-SIZE: 12pt; FONT-FAMILY: 'Times New Roman'; mso-fareast-font-family: 'MS Mincho'; mso-ansi-language: EN-US; mso-fareast-language: JA; mso-bidi-language: AR-SA"><strong><img  height="307" alt="45 percent of featues implemented are never ever used" src="./../../../core.mgmt.common.extend_supp/guidances/concepts/./resources/iteration.gif" width="489" /></strong></span></span><br />
&nbsp; 
<p>
    <strong><em>Figure 2.3. Most Features Implemented Are Never or Rarely Used.<br />
    </em></strong><em>According to the Standish Group, an amazing 45 percent of features implemented are never used, while
    another 19 percent are used only rarely. If features never used were not implemented in the first place, development
    time would be cut in about half. Further, since productivity is typically measured in the form of lines of code or
    functionality delivered, this improvement would not register as a productivity increase using standard productivity
    measures.</em><br />
</p></td>
</tr>
</table>
</div>
<table class="copyright" border="0" cellspacing="0" cellpadding="0">
<tr>
<td class="copyright"><p> This program and the accompanying materials are made available under the<br />
  <a href="http://www.eclipse.org/org/documents/epl-v10.php" target="_blank">Eclipse 
  Public License V1.0</a>, which accompanies this distribution. </p><p/><p> <a class="elementLink" href="./../../../core.default.release_copyright.base/guidances/supportingmaterials/openup_copyright_C3031062.html" guid="_UaGfECcTEduSX6N2jUafGA">OpenUP Copyright</a></p></td>
</tr>
</table>
</td>
</tr>
</table>
</body>
<script type="text/javascript" language="JavaScript">
				contentPage.onload();
			</script>
</html>
